using System;
using System.Collections.Generic;
using System.Linq;
using M0;
using Newtonsoft.Json;
using UnityEngine;

namespace M1
{
    public class Task管理器 : BaseSingleMono<Task管理器>
    {
        private const string Task管理器Key = "Task管理器Key";
        [SerializeField]private List<任务缓存> Datas;


        public List<任务缓存> Get进行中的任务()
        {
            List<任务缓存> res = new List<任务缓存>();
            foreach (var VARIABLE in Datas)
            {
                任务缓存 r = new 任务缓存();
                r.任务类型 = VARIABLE.任务类型;
                r.进行中的任务 = VARIABLE.进行中的任务.Where(w => !w.完成).ToList();
                res.Add(r);
            }
            return res;
        }
        public List<任务缓存> Get完成的任务()
        {
            List<任务缓存> res = new List<任务缓存>();
            foreach (var VARIABLE in Datas)
            {
                任务缓存 r = new 任务缓存();
                r.任务类型 = VARIABLE.任务类型;
                r.进行中的任务 = VARIABLE.进行中的任务.Where(w => w.完成).ToList();
                res.Add(r);
            }
            return res;
        }
        
        private void Start()
        {
            Datas = M.Get缓存<List<任务缓存>>(Task管理器Key);
            M.Event.AddEvent(M.EventKey_保存数据,单独保存);
        }

        public void 单独保存()
        {
            if (Datas != null && Datas.Count > 0)
            {
                M.保存缓存(Task管理器Key,JsonConvert.SerializeObject(Datas));
            }
        }
    
        private 任务进度 接受任务配置_任务进度(I任务配置 config)
        {
            任务进度 n = new 任务进度();
            n.Id = config.GetId;
            n.任务目标 = config.Get目标;
            n.完成进度 = 0;
            return n;
        }
    
        public void 接受任务(I任务配置 config)
        {
            if (Datas == null) Datas = new List<任务缓存>();
            TaskType type = config.Get类型;
            int index = Datas.FindIndex(f => f.任务类型 == type);
            if (index < 0)
            {
                任务缓存 d = new 任务缓存();
                d.任务类型 = type;
                d.进行中的任务 = new List<任务进度>();
                d.进行中的任务.Add(接受任务配置_任务进度(config));
                Datas.Add(d);
            }
            else
            {
                bool 已经接受 = Datas[index].进行中的任务.Any(a => a.Id == config.GetId);
                if (!已经接受)
                {
                    Datas[index].进行中的任务.Add(接受任务配置_任务进度(config));
                }
            }
            M.Event.DoEvent(M.EventKey_接受任务,config.GetId);
        }

        public void 增加任务进度(I任务配置 data)
        {
            List<int> 完成任务 = new List<int>();
            foreach ( var VARIABLE in Datas)
            {
                if (VARIABLE.任务类型 == data.Get类型)
                {
                    foreach (var task in VARIABLE.进行中的任务)
                    {
                        if (task.Id == data.GetId)
                        {
                            task.完成进度++;
                            if (task.完成进度 >= task.任务目标)
                            {
                                task.完成 = true;
                                完成任务.Add(task.Id);
                               
                            }
                            else
                            {
                                M.Event.DoEvent(M.EventKey_更新任务,(task.Id,task.任务目标,task.完成进度));
                            }
                        }
                    }
                }
            }

            foreach (var VARIABLE in 完成任务)
            {
                M.Event.DoEvent(M.EventKey_完成任务,VARIABLE);
            }
        }
        
    }
    
    public enum TaskType
    {
        主线任务,
        支线任务,
        每日任务,
    }
    
    [Serializable]
    public class 任务缓存
    {
        public TaskType 任务类型;
        public List<任务进度> 进行中的任务;
    }
    
    [Serializable]
    public class 任务进度
    {
        public int Id;
        public int 完成进度;
        public int 任务目标;
        public bool 完成;
    }
    
    public interface I任务配置
    {
        int GetId { get; }
        TaskType Get类型 { get; }
        int Get目标 { get; }
    }

}



